La librairie standard du C++
*******************************

Certaines des librairies présentées dans ce chapitre n'ont pas toujours été fournies par le langage C++.
Par exemple, avant le C++11, la gestion des threads nécessitait d'intégrer la librairie fournie par le noyau Linux ou le noyau Windows suivant le système choisi. Ces univers étant différents, leurs librairies l'étaient aussi, ce qui rendait difficile le portage d'un programme C++ d'un système d'exploitation à l'autre. 
L’utilisation des librairies standardisées du C++ permet ainsi de créer du code multi-plateforme.
Pour la petite histoire, il faudra attendre le C++17 pour que le langage intègre, enfin,
une librairie `<Filesystem> <https://en.cppreference.com/w/cpp/filesystem>`_
permettant d'effectuer des opérations sur le système de fichiers (copie, renommage...).



Présentation
============

La **librairie standard** du C++ (STD), aussi appelée la **bibliothèque standard** du C++ (C++ Standard Library en anglais) fournit :

	* Des types : comme le type *string* servant à manipuler efficacement les chaînes de caractères
	* Des objets : comme *cout* permettant d'effecteur des affichages dans la console (console out)
	* Des conteneurs : pile, liste chaînée, liste de taille dynamique, dictionnaire (STL)
	* Des algorithmes : comme les algorithmes de tri (STL)


La bibliothèque standard du C++ est le résultat de l'évolution de plusieurs bibliothèques développées par différents acteurs de l'univers du C++.
L'ensemble de la bibliothèque est spécifié dans la norme ISO qui définit également le langage : ISO/CEI 14882. 
Une des principales briques de cette bibliothèque est sans aucun doute la STL (abréviation de « Standard Template Library ») fournissant de nombreux conteneurs génériques.

Il existe actuellement plusieurs implémentations de la STD provenant des acteurs majeurs du monde informatique, 
acteurs qui évidemment proposent aussi des compilateurs C++ :



.. csv-table::
	:header: Nom, Acronyme
	:widths: 10, 10
	:delim: !
	
	GNU C++ Standard Library		! libstdc++	GPLv3
	LLVM C++ Standard Library		! libc++
	NVIDIA C++ Standard Library	[3]	! libcu++
	Microsoft C++ Standard Library	! MSVC STL	

Pour mieux comprendre l'organisation de la librairie STD, 
nous vous recommandons de consulter la `page dédiée <https://www.cplusplus.com/reference/>`_ sur le site cplusplus.com.

Le site a classé les librairies ainsi :

.. image:: listLIB.png  

En cliquant sur le signe + à coté d'une librairie, on obtient une vue plus détaillée :
	  

  * La rubrique *C Library* : présentent les librairies préexistantes en C qui ont été portées dans la librairie STD. Leur nouveau nom perd l'extension *.h* et se retrouve précédé de la lettre *c*. Ainsi, on n'écriera plus #include <stdio.h> mais #include <cstdio>. On peut citer :
	
		* **<cmath>** pour les fonctions mathématiques
		* <cstdio> pour les nostalgiques du printf
		* **<cstdlib>** pour la génération de nombres aléatoires
		
  * La rubrique *Containers* propose différentes structures de données venant de la STL : 
  
		* **<vector>** pour les tableaux dynamiques
		* **<map>** pour les dictionnaires
		
  * La rubrique *Input/output* propose diverses classes gérant les entrées/sorties 
  
		* **<iostream>** pour les entrées sorties console
		* **<fstream>** pour les entrées sorties fichier
		
  * La rubrique *thread* propose diverses opérations pour la gestion des threads
		
  * La rubrique *Other* comprend de nombreux sujets divers et variés comme
		
		* **<string>** pour les chaînes de caractères (un chapitre est dédié à cette classe)
		* **<chrono>** (C++11) pour une gestion fine du temps
		 
		
Pour avoir accès à une librairie il suffit d'écrire :

.. code-block:: cpp
	
	#include <NomLibrairie>
	
	int main()
	{
	   std::MaFonction(...);
	}

Pour éviter d'avoir à écrire *std::* vous pouvez utiliser la facilité suivante :

.. code-block:: cpp
	
	#include <NomLibrairie>
	
	using namespace std;
	int main()
	{
	   MaFonction(...);
	}


		
		
Les librairies en détail
========================

<cmath>
-------

On y trouve des fonctions mathématiques comme :

	* Les fonctions trigonométriques : *cos/sin/tan...*
	* Les fonctions exponentielles : *exp/log...*
	* Les fonctions puissance : *pow/sqrt*
	* Les fonctions d'arrondi : *ceil/floor/round*
	* La valeur absolue : *abs*
	
<cstdlib>
---------

Cette librairie propose la fonction `rand() <https://www.cplusplus.com/reference/cstdlib/rand/>`_ 
qui retourne un entier généré aléatoirement. Couplé à l'opérateur modulo, vous pouvez maintenant générer
des nombres entiers compris entre *0* et *n*.


<iostream>
----------

Cette librairie propose un objet *cout* permettant d'effectuer des sorties sur la console de manière plus intuitive 
que la fonction *printf*. Pour cela, l'opérateur << a été redéfini pour accepter des messages envoyés vers la console.
Il accepte tous les types fondamentaux. Pour les booléens cependant, il affiche 0 pour *false* et 1 pour *true*.
La librairie <iostream> inclut aussi des constantes comme *endl* pour effectuer un retour à la ligne.
Nous pouvons ainsi écrire :

.. code-block:: cpp

	#include <iostream>
	
	using namespace std;
	int main()
	{
	   int a = 17;
	   string t = "Bonjour";
	   cout << a;
	   cout << endl;
	   cout << t;
	}
	
Il est possible de chaîner plusieurs affichages à la suite. Cependant, les éléments sont accolés, ainsi *cout << 18 << 13* affiche 1813.
Il faut alors penser à insérer des espacements supplémentaires pour rendre l'affichage lisible :

.. code-block:: cpp

	   cout << "Bonjour " << a << endl << "Age : " << t << endl;

Formatage des nombres flottants
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

La librairie <iomanip> fournit une fonction *setprecision()* 
permettant de contrôler l'affichage des nombres flottants :


.. code-block:: cpp

	#include <iostream>
	#include <iomanip>
	using namespace std;
	int main()
	{
	   cout << setprecision(5) << 3.141519 << endl;   // ==>> 3.1415  5 chiffres
	   cout << setprecision(3) << 3.141519 << endl;   // ==>> 3.14    3 chiffres
	}

Formatage des nombres entiers
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
La librairie <iomanip> fournit une fonction *setw()* (set width)
permettant d'indiquer la place que doit prendre un affichage.
Ainsi, si un nombre prend 2 chiffres et que le largeur est fixée à 5, trois caractères seront rajoutés.
La fonction *setfill()* permet d'indiquer le caractère servant de remplissage.
Voici un exemple :

.. code-block:: cpp

	#include <iomanip>
	#include <iostream>

	int main()
	{
		std::cout << std::setfill('-');
		std::cout << std::setw(5) << 25 << std::endl;
		std::cout << std::setw(5) << 148;
	}
	
	==>> ---25
	==>> --148
	


<string>
--------
	
Cette librairie fournit la classe *string* permettant de stocker des chaînes de caractères.
Une page complète lui est dédiée dans ce cours. On trouve aussi des fonctions permettant
les conversions de chaînes de caractères vers les numériques.

La librairie *string* fournit aussi une fonction très importe *getline* permettant de 
lire de manière générique toute sorte de flux : clavier, chaîne de caractères, fichier... 
Une page spéciale lui sera consacrée.


<vector> et <map>
-----------------
Si vous cherchez des containers de données de taille dynamique c'est ici qu'il faut venir !
Les tableaux habituels sont contraints par une taille fixe et peu importante.
Grâce à ces containers, nous sommes enfin libérés de ces deux contraintes.
Une page spéciale leur sera dédiée.



<chrono>
--------
Le C++11 offre enfin un outil pour gérer et mesurer avec précision le temps !


.. code-block:: cpp

	#include <iostream>
	#include <chrono>
 
	using namespace std;
	void FntCalcul()
	{
		int t = 1000;  // calculs prenant du temps
		for (int i = 0 ; i < 10000; i++) t *= t;
	}
	
	int main()
	{
		auto start = chrono::steady_clock::now();
		FntCalcul();
		auto end   = chrono::steady_clock::now();	 
		double DeltaTns =  (end - start).count();
		cout << "Temps de calcul en nanosecondes : " << DeltaTns;
	}

La librairie <chrono> ayant créé des types à la syntaxe bien ardue,
cette librairie aura au moins l'avantage de vous pousser à découvrir l'usage du mot clef auto !


<thread>
--------

Cette librairie offre une fonction *sleep_for()* permettant de mettre le programme en attente pour une durée fixée.
Voici un exemple :

.. code-block:: cpp

	#include <iostream>
	#include <chrono>
	#include <thread>
	 
	int main()
	{
	 
		std::cout << "Hello !\n" << std::flush;                // flush force l'affichage pour qu'il ait lieu avant la pause
		std::this_thread::sleep_for(std::chrono::seconds(1));  // gèle le programme pendant 1 seconde
		std::cout << "Me revoilà !\n";
	}


 
.. quiz:: librairies
	:title: Les noms des librairies
	
		
	Pour chaque librairie donnez son nom en minuscules sans les <> 
	
	.. csv-table::
		:widths: 10, 10
		:delim: !
		
		La librairie contenant la fonction rand()   		!   :quiz:`{"type":"FB","answer":"cstdlib"}`
		La librairie pour mesurer le temps avec précision 	!   :quiz:`{"type":"FB","answer":"chrono"}`
		La librairie contenant l'objet cout         		!   :quiz:`{"type":"FB","answer":"iostream"}`
		La librairie standard du C++ 						! 	:quiz:`{"type":"FB","answer":"std"}`
		La librairie pour les chaînes de caractères 		!   :quiz:`{"type":"FB","answer":"string"}`
		La librairie pour les tableaux dynamiques   		!   :quiz:`{"type":"FB","answer":"vector"}`
		La librairie contenant les fonctions mathématiques 	!   :quiz:`{"type":"FB","answer":"cmath"}`